home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 #1 / Ham Radio 2000.iso / ham2000 / tcp_ip / tnos / tnos100s / smisc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-11-13  |  12.2 KB  |  667 lines

  1. /* Miscellaneous Internet servers: discard, echo and remote
  2.  * Copyright 1991 Phil Karn, KA9Q
  3.  */
  4. #include <stdio.h>
  5. #include <time.h>
  6. #include <dos.h>
  7. #include "global.h"
  8. #include "config.h"
  9. #include "netuser.h"
  10. #include "mbuf.h"
  11. #include "socket.h"
  12. #include "proc.h"
  13. #include "remote.h"
  14. #include "smtp.h"
  15. #include "tcp.h"
  16. #include "nr4.h"
  17. #include "commands.h"
  18. #include "hardware.h"
  19. #include "mailbox.h"
  20.  
  21. char *Rempass = "";    /* Remote access password */
  22. extern char *Quotes, *MMotd;
  23.  
  24. static int chkrpass __ARGS((struct mbuf *bp));
  25. static void discserv __ARGS((int s,void *unused,void *p));
  26. static void echoserv __ARGS((int s,void *unused,void *p));
  27. static void quoteserv __ARGS((int s,void *unused,void *p));
  28. static void timeserv __ARGS((int s,void *unused,void *p));
  29. static void daytimeserv __ARGS((int s,void *unused,void *p));
  30. char *getquote __ARGS((void));
  31.  
  32. static int Rem = -1;
  33.  
  34. int
  35. deleteserver (mysocket)
  36. int *mysocket;
  37. {
  38.     if (*mysocket != -1)    {
  39.         close_s(*mysocket);
  40.         *mysocket = -1;
  41.     } else
  42.         tprintf ("The server is not active - nothing to stop!\n");
  43.     return 0;
  44. }
  45.  
  46.  
  47. /* Start up a TCP server */
  48. int
  49. installserver(argc,argv,mysocket,listener,defport,procname,proc,size,parm)
  50. int argc;
  51. char *argv[];
  52. int *mysocket, defport;
  53. char *listener, *procname;
  54. void (*proc)();
  55. int size;
  56. void *parm;
  57. {
  58. struct sockaddr_in lsocket;
  59. int s;
  60.  
  61.     if(*mysocket != -1){
  62.         return 0;
  63.     }
  64.     psignal(Curproc,0);     /* Don't keep the parser waiting */
  65.     chname(Curproc,listener);
  66.  
  67.     lsocket.sin_family = AF_INET;
  68.     lsocket.sin_addr.s_addr = INADDR_ANY;
  69.     if(argc < 2)
  70.         lsocket.sin_port = defport;
  71.     else
  72.         lsocket.sin_port = atoi(argv[1]);
  73.     *mysocket = socket(AF_INET,SOCK_STREAM,0);
  74.     bind(*mysocket,(char *)&lsocket,sizeof(lsocket));
  75.     listen(*mysocket,1);
  76.     for(;;){
  77.         if((s = accept(*mysocket,NULLCHAR,(int *)NULL)) == -1)
  78.             break;    /* Service is shutting down */
  79.  
  80.         /* Low mem check now done in tcpin.c - WG7J */
  81.         /* Spawn a server */
  82.         newproc(procname,size,proc,s,parm,NULL,0);
  83.     }
  84.     return 0;
  85. }
  86.  
  87.  
  88. #ifdef ALLSERV
  89. static int Sdisc = -1;
  90. static int Stime = -1;
  91. static int Squote = -1;
  92. static int Sdaytime = -1;
  93. static int Secho = -1;
  94. static int Srlogin = -1;
  95. #ifdef TUTOR
  96. int Stutor = -1;
  97. int Sinfo = -1;
  98. int Snews = -1;
  99. #endif
  100.  
  101. #define DIFFTIME 2208988800
  102.  
  103. #define T_TIME         0
  104. #define T_DAYTIME    1
  105. #define    T_DISCARD    2
  106. #define T_ECHO        3
  107. #define T_QUOTE        4
  108.  
  109. static void
  110. handleserver(s,name,type)
  111. int s, type;
  112. char *name;
  113. {
  114. struct mbuf *bp;
  115. time_t currtime;
  116. char buf[20];
  117.  
  118.     sockowner(s,Curproc);
  119.     sprintf (buf, "open %s", name);
  120.     log(s,buf);
  121.     switch (type)        {
  122.         case T_DISCARD:        while(recv_mbuf(s,&bp,0,NULLCHAR,NULL) > 0)
  123.                         free_p(bp);
  124.                     break;
  125.         case T_QUOTE:        {
  126.                     char buf2[512], *cp;
  127.                     cp = getquote();
  128.                     currtime = time (&currtime);
  129.                     sprintf (buf2,"\nQuote-of-the-Day at '%s' on %s\n", Hostname, ctime(&currtime));
  130.                     bp = qdata (buf2, strlen(buf2));
  131.                     send_mbuf (s, bp,0,NULLCHAR, 0);
  132.                     bp = qdata (cp, strlen(cp));
  133.                     free (cp);
  134.                     }
  135.                     goto common;
  136.         case T_TIME:
  137.         case T_DAYTIME:        currtime = time (&currtime);
  138.                     if (type == T_DAYTIME)    /* daytime protocol */
  139.                         bp = qdata (ctime(&currtime), 26);
  140.                     else    {
  141.                         /*
  142.                          * Change 1970 start time to 1900 start time,
  143.                          * and put it in network order
  144.                          */
  145.                         put32(buf,time((time_t *)0)+DIFFTIME);
  146.  
  147.                         /* enqueue for transmission */
  148.                         bp = qdata(buf,sizeof(int32));
  149.                     }
  150. common:                    if (send_mbuf(s,bp,0,NULLCHAR,0) == -1)        {
  151.                         sprintf (buf, "%s failed", name);
  152.                         log(s,buf);
  153.                     }    
  154.                     break;
  155.         case T_ECHO:        while(recv_mbuf(s,&bp,0,NULLCHAR,NULL) > 0)
  156.                         send_mbuf(s,bp,0,NULLCHAR,0);
  157.  
  158.         }
  159.     sprintf (buf, "close %s", name);
  160.     log(s,buf);
  161.     close_s(s);
  162. }
  163.  
  164.  
  165. /* Start up TCP discard server */
  166. int
  167. dis1(argc,argv,p)
  168. int argc;
  169. char *argv[];
  170. void *p;
  171. {
  172.     return (installserver (argc, argv, &Sdisc, "Discard listener", IPPORT_DISCARD,
  173.         "Discard server", discserv, 576, NULL));
  174. }
  175.  
  176.  
  177. static void
  178. discserv(s,unused,p)
  179. int s;
  180. void *unused;
  181. void *p;
  182. {
  183.     handleserver (s, "discard", T_DISCARD);
  184. }
  185.  
  186. /* Stop discard server */
  187. int
  188. dis0(argc,argv,p)
  189. int argc;
  190. char *argv[];
  191. void *p;
  192. {
  193.     return (deleteserver (&Sdisc));
  194. }
  195.  
  196. /* Start up TCP time server */
  197. int
  198. time1(argc,argv,p)
  199. int argc;
  200. char *argv[];
  201. void *p;
  202. {
  203.     return (installserver (argc, argv, &Stime, "Time listener", IPPORT_TIME,
  204.         "Time server", timeserv, 512, NULL));
  205. }
  206.  
  207. static void
  208. timeserv(s,unused,p)
  209. int s;
  210. void *unused;
  211. void *p;
  212. {
  213.     sockmode(s, SOCK_BINARY);
  214.     handleserver (s, "time", T_TIME);
  215. }
  216.  
  217. /* Stop time server */
  218. int
  219. time0(argc,argv,p)
  220. int argc;
  221. char *argv[];
  222. void *p;
  223. {
  224.     return (deleteserver (&Stime));
  225. }
  226.  
  227. /* Start up TCP daytime server */
  228. int
  229. daytime1(argc,argv,p)
  230. int argc;
  231. char *argv[];
  232. void *p;
  233. {
  234.     return (installserver (argc, argv, &Sdaytime, "Daytime listener", IPPORT_DAYTIME,
  235.         "Daytime server", daytimeserv, 576, NULL));
  236. }
  237.  
  238. static void
  239. daytimeserv(s,unused,p)
  240. int s;
  241. void *unused;
  242. void *p;
  243. {
  244.     handleserver (s, "daytime", T_DAYTIME);
  245. }
  246.  
  247. /* Stop time server */
  248. int
  249. daytime0(argc,argv,p)
  250. int argc;
  251. char *argv[];
  252. void *p;
  253. {
  254.     return (deleteserver (&Sdaytime));
  255. }
  256.  
  257. /* Start up TCP echo server */
  258. int
  259. echo1(argc,argv,p)
  260. int argc;
  261. char *argv[];
  262. void *p;
  263. {
  264.     return (installserver (argc, argv, &Secho, "Echo listener", IPPORT_ECHO,
  265.         "Echo server", echoserv, 2048, NULL));
  266. }
  267. static void
  268. echoserv(s,unused,p)
  269. int s;
  270. void *unused;
  271. void *p;
  272. {
  273.     handleserver (s, "echo", T_ECHO);
  274. }
  275.  
  276. /* stop echo server */
  277. int
  278. echo0(argc,argv,p)
  279. int argc;
  280. char *argv[];
  281. void *p;
  282. {
  283.     return (deleteserver (&Secho));
  284. }
  285.  
  286. #endif /*ALLSERV*/
  287.  
  288. extern void where_outta_here __ARGS((int resetme));
  289.  
  290. /* Start remote exit/reboot server */
  291. int
  292. rem1(argc,argv,p)
  293. int argc;
  294. char *argv[];
  295. void *p;
  296. {
  297. struct sockaddr_in lsocket,fsock;
  298. int i;
  299. int command;
  300. struct mbuf *bp;
  301. int32 addr;
  302. char temp[20];
  303.  
  304.     if(Rem != -1)
  305.         return 0;
  306.     psignal(Curproc,0);
  307.     chname(Curproc,"Remote listener");
  308.     lsocket.sin_family = AF_INET;
  309.     lsocket.sin_addr.s_addr = INADDR_ANY;
  310.     if(argc < 2)
  311.         lsocket.sin_port = IPPORT_REMOTE;
  312.     else
  313.         lsocket.sin_port = atoi(argv[1]);
  314.     
  315.     Rem = socket(AF_INET,SOCK_DGRAM,0);
  316.     bind(Rem,(char *)&lsocket,sizeof(lsocket));
  317.     for(;;){
  318.         i = sizeof(fsock);
  319.         if(recv_mbuf(Rem,&bp,0,(char *)&fsock,&i) == -1)
  320.             break;
  321.         command = PULLCHAR(&bp);
  322.  
  323.         switch(command){
  324. #ifdef    MSDOS    /* Only present on PCs running MSDOS */
  325.         case SYS_RESET:
  326.             i = chkrpass(bp);
  327.             log(Rem,"Remote reset %s %s",
  328.              psocket((struct sockaddr *)&fsock),
  329.              i == 0 ? "PASSWORD FAIL" : "" );
  330.             if(i != 0){
  331.                 /*Indicate a hardware reset*/
  332.                 where_outta_here(1);
  333.             }
  334.             break;
  335. #endif
  336.         case SYS_EXIT:
  337.             i = chkrpass(bp);
  338.             log(Rem,"Remote exit %s %s",
  339.              psocket((struct sockaddr *)&fsock),
  340.              i == 0 ? "PASSWORD FAIL" : "" );
  341.             if(i != 0){
  342.                 /*No reset*/
  343.                 where_outta_here(0);
  344.             }
  345.             break;
  346.         case KICK_ME:
  347.             if(len_p(bp) >= sizeof(int32))
  348.                 addr = pull32(&bp);
  349.             else
  350.                 addr = fsock.sin_addr.s_addr;
  351.  
  352.             /* get round strange printf bug */
  353.             strcpy(temp, inet_ntoa(addr));
  354.  
  355.             log(Rem,"Remote kick by %s for host %s",
  356.              psocket((struct sockaddr *)&fsock), temp);
  357. #ifdef NETROM
  358.             donodetick();        /* g3rra's idea!..hmmm */
  359. #endif /* NETROM */
  360.             kick(addr);
  361.             smtptick((void *)addr);
  362.             break;
  363.         }
  364.         free_p(bp);
  365.     }
  366.     close_s(Rem);
  367.     Rem = -1;
  368.     return 0;
  369. }
  370.  
  371. /* Check remote password */
  372. static int
  373. chkrpass(bp)
  374. struct mbuf *bp;
  375. {
  376.     char *lbuf;
  377.     int16 len;
  378.     int rval = 0;
  379.  
  380.     len = len_p(bp);
  381.     if(strlen(Rempass) != len)
  382.         return rval;
  383.     lbuf = mallocw(len);
  384.     pullup(&bp,lbuf,len);
  385.     if(strncmp(Rempass,lbuf,len) == 0)
  386.         rval = 1;
  387.     free(lbuf);
  388.     return rval;
  389. }
  390.  
  391. int
  392. rem0(argc,argv,p)
  393. int argc;
  394. char *argv[];
  395. void *p;
  396. {
  397.     close_s(Rem);
  398.     return 0;
  399. }
  400.  
  401.  
  402. /* Start up TCP quote server */
  403. int
  404. quote1(argc,argv,p)
  405. int argc;
  406. char *argv[];
  407. void *p;
  408. {
  409.     return (installserver (argc, argv, &Squote, "Quote listener", IPPORT_QUOTE,
  410.         "Quote server", quoteserv, 1536, NULL));
  411. }
  412.  
  413. static void
  414. quoteserv(s,unused,p)
  415. int s;
  416. void *unused;
  417. void *p;
  418. {
  419.     handleserver (s, "quote", T_QUOTE);
  420. }
  421.  
  422. /* Stop quote server */
  423. int
  424. quote0(argc,argv,p)
  425. int argc;
  426. char *argv[];
  427. void *p;
  428. {
  429.     return (deleteserver (&Squote));
  430. }
  431.  
  432.  
  433. char *
  434. getquote()
  435. {
  436. char buf2[512];
  437. FILE *fp;
  438. int size;
  439.  
  440.     if(Squote == -1)
  441.         return (NULLCHAR);
  442.     if((fp = fopen(Quotes,READ_TEXT)) == NULLFILE)    {
  443.         if (MMotd != NULLCHAR)
  444.             return (strdup(MMotd));
  445.         else
  446.             return (NULLCHAR);
  447.     } else    {
  448.         struct date dt;
  449.         getdate (&dt);
  450.         while(fgets(buf2,512,fp) != NULLCHAR)     {
  451.             if (!--dt.da_day)
  452.                 break;
  453.         }
  454.     }
  455.     fclose (fp);
  456.     if (*buf2 == '%')    {
  457.         rip (buf2);
  458.         if ((fp = fopen (&buf2[1],READ_TEXT)) == NULLFILE)    {
  459.             printf ("Couldn't open '%s'\n", &buf2[1]);
  460.             return (NULLCHAR);
  461.         }
  462.         else    {
  463.             size = fread (buf2, 1, 512, fp);
  464.             buf2[size] = 0;
  465.             fclose (fp);
  466.         }
  467.     }
  468.     return (strdup (buf2));
  469. }
  470.  
  471.  
  472. /* Execute user quote command */
  473. int
  474. doquote(argc,argv,p)
  475. int argc;
  476. char *argv[];
  477. void *p;
  478. {
  479. char buf[32], buf2[32], *cptr;
  480. int i = 0;
  481.  
  482.     free (argv[0]);
  483.     argv[0] = strdup ("telnet");
  484.     if (argv[2])
  485.         free (argv[2]);
  486.     argv[2] = strdup ("17");
  487.     if (!argv[1])
  488.         argv[1] = strdup (Hostname);
  489.     return dotelnet(3,argv,p);
  490. }
  491.  
  492.  
  493. #ifdef RLOGINSERV
  494. static void
  495. rloginserver(s,o,p)
  496. int s;
  497. void *o;
  498. void *p;
  499. {
  500.     mbx_incom (s, (void *)RLOGIN_LINK, p);
  501. }
  502. #endif
  503.  
  504.  
  505. #ifdef TUTOR
  506. extern void tutorserv __ARGS((char *, struct mbx *, int, int, int));
  507. static char *tut[] = {"tutor", "info", "news"};
  508.  
  509. static void
  510. tutorserver(s,mode,p)
  511. int s;
  512. void *mode;
  513. void *p;
  514. {
  515. int outsave, insave;
  516.  
  517.     sockmode(s,SOCK_ASCII);
  518.     sockowner(s,Curproc);
  519.     log (s, "open %s server", tut[(int) mode]);
  520.     outsave = Curproc->output;
  521.     Curproc->output = s;
  522.     insave = Curproc->input;
  523.     Curproc->input = s;
  524.     tutorserv ("NoName", NULLMBX, (int) mode, 0, 1);
  525.     Curproc->input = insave;
  526.     Curproc->output = outsave;
  527.     log(s,"close %s server", tut[(int) mode]);
  528.     close_s(s);
  529. }
  530.  
  531. #ifdef RLOGINSERV
  532. /* Start up RLOGIN server */
  533. int
  534. rlogin1(argc,argv,p)
  535. int argc;
  536. char *argv[];
  537. void *p;
  538. {
  539.     return (installserver (argc, argv, &Srlogin, "RLogin listener", IPPORT_RLOGIN,
  540.         "RLogin server", rloginserver, 2048, (void *) 0));
  541. }
  542.  
  543. /* Stop RLOGIN server */
  544. int
  545. rlogin0(argc,argv,p)
  546. int argc;
  547. char *argv[];
  548. void *p;
  549. {
  550.     return (deleteserver (&Srlogin));
  551. }
  552. #endif
  553.  
  554. /* Start up TCP tutorial server */
  555. int
  556. tutor1(argc,argv,p)
  557. int argc;
  558. char *argv[];
  559. void *p;
  560. {
  561.     return (installserver (argc, argv, &Stutor, "Tutor listener", IPPORT_TUTOR,
  562.         "Tutor server", tutorserver, 2048, (void *) 0));
  563. }
  564.  
  565. /* Stop tutorial server */
  566. int
  567. tutor0(argc,argv,p)
  568. int argc;
  569. char *argv[];
  570. void *p;
  571. {
  572.     return (deleteserver (&Stutor));
  573. }
  574.  
  575. /* Start up TCP tutorial server */
  576. int
  577. info1(argc,argv,p)
  578. int argc;
  579. char *argv[];
  580. void *p;
  581. {
  582.     return (installserver (argc, argv, &Sinfo, "Info listener", IPPORT_INFO,
  583.         "Info server", tutorserver, 2048, (void *) 1));
  584. }
  585.  
  586. /* Stop tutorial server */
  587. int
  588. info0(argc,argv,p)
  589. int argc;
  590. char *argv[];
  591. void *p;
  592. {
  593.     return (deleteserver (&Sinfo));
  594. }
  595.  
  596. /* Start up TCP news server */
  597. int
  598. news1(argc,argv,p)
  599. int argc;
  600. char *argv[];
  601. void *p;
  602. {
  603.     return (installserver (argc, argv, &Snews, "News listener", IPPORT_NEWS,
  604.         "News server", tutorserver, 2048, (void *) 2));
  605. }
  606.  
  607. /* Stop news server */
  608. int
  609. news0(argc,argv,p)
  610. int argc;
  611. char *argv[];
  612. void *p;
  613. {
  614.     return (deleteserver (&Snews));
  615. }
  616.  
  617. char WhichTutor = 0;
  618.  
  619. /* Execute user tutor command */
  620. int
  621. dotutor(argc,argv,p)
  622. int argc;
  623. char *argv[];
  624. void *p;
  625. {
  626. char buf[6];
  627. int i = WhichTutor;
  628.  
  629.     WhichTutor = 0;
  630.     free (argv[0]);
  631.     argv[0] = strdup ("telnet");
  632.     if (argv[2])
  633.         free (argv[2]);
  634.     sprintf (buf, "%-d", IPPORT_TUTOR - i);
  635.     argv[2] = strdup (buf);
  636.     if (!argv[1])
  637.         argv[1] = strdup (Hostname);
  638.     return dotelnet(3,argv,p);
  639. }
  640.  
  641.  
  642. /* Execute user info command */
  643. int
  644. doinfo(argc,argv,p)
  645. int argc;
  646. char *argv[];
  647. void *p;
  648. {
  649.     WhichTutor = 1;
  650.     return (dotutor(argc, argv, p));
  651. }
  652.  
  653.  
  654. /* Execute user info command */
  655. int
  656. donews(argc,argv,p)
  657. int argc;
  658. char *argv[];
  659. void *p;
  660. {
  661.     WhichTutor = 2;
  662.     return (dotutor(argc, argv, p));
  663. }
  664.  
  665.  
  666. #endif
  667.